﻿// Modules to control application life and create native browser window
const {
	app,
	BrowserWindow,
	Menu,
	Tray,
	dialog,
	globalShortcut,
	nativeImage,
	ipcMain,
	shell,
	session
} = require('electron')
const path = require('path')
const fs = require('fs')
const https = require('https')
const http = require('http')
const { URL } = require('url')
// 增加Axios用于HTTP请求
const axios = require('axios')
// 使用SVG图标文件，不再需要清除缓存图标的JS模块
// const { clearCacheIcon } = require('./assets/icons/clear-cache')
let tray = null
let mainWindow = null

// 设置详细日志输出
process.env.ELECTRON_ENABLE_LOGGING = true;
process.env.ELECTRON_DEBUG_LEVEL = 'info';

// 设置自定义的用户数据目录，避免缓存权限问题
const userDataPath = path.join(app.getPath('userData'), 'AppData');
try {
	if (!fs.existsSync(userDataPath)) {
		fs.mkdirSync(userDataPath, { recursive: true });
	}
	app.setPath('userData', userDataPath);
	console.log('设置用户数据目录:', userDataPath);
} catch (err) {
	console.error('设置用户数据目录失败:', err);
}

// 避免硬件加速导致的问题
app.disableHardwareAcceleration();

// 配置应用程序
app.commandLine.appendSwitch('disable-features', 'OutOfBlinkCors');
app.commandLine.appendSwitch('disable-site-isolation-trials');
app.commandLine.appendSwitch('no-sandbox');

function createWindow() {

	// Create the browser window.
	mainWindow = new BrowserWindow({
		icon: "favicon.ico",
		frame: false, // 完全无边框窗口
		webPreferences: {
			preload: path.join(__dirname, 'preload.js'),
			nodeIntegration: false,
			contextIsolation: true,
			webviewTag: true,
			webSecurity: false,
			partition: 'persist:main'
		}
	})

	const gotTheLock = app.requestSingleInstanceLock()
	if (!gotTheLock) {
		app.quit()
	} else {
		app.on('second-instance', (event, commandLine, workingDirectory) => {
			// 当运行第二个实例时,将会聚焦到mainWindow这个窗口
			if (mainWindow) {
				if (mainWindow.isMinimized()) mainWindow.restore()
				mainWindow.focus()
				mainWindow.show()
			}
		})
	}

	// 加载主窗口首页，包含内置标题栏
	mainWindow.loadFile('index.html')

	// 显示窗口
	mainWindow.once('ready-to-show', () => {
		// 设置为false则应用启动时窗口处于隐藏状态，只在托盘显示
		const showOnStartup = true; // 可设置为false使应用启动时隐藏
		
		if (showOnStartup) {
			mainWindow.show();
			mainWindow.maximize();
		} else {
			// 启动后不显示主窗口，只在托盘中显示图标
			console.log('应用启动时保持隐藏状态，按Alt+Space或点击托盘图标显示');
		}
		
		// 应用启动后检查更新
		setTimeout(() => {
			checkForUpdates(true);
		}, 1000); // 启动1秒后检查更新
	})

	// 窗口失去焦点时隐藏（可选功能）
	let hideOnBlur = false; // 默认禁用
	if (hideOnBlur) {
		mainWindow.on('blur', () => {
			if (mainWindow.isVisible() && !mainWindow.isMinimized()) {
				mainWindow.hide();
			}
		});
	}

	//配置ESC键退出全屏
	tray = new Tray(path.join(__dirname, './favicon.ico'))
	
	// 使用SVG图标文件
	const cacheIcon = nativeImage.createFromPath(path.join(__dirname, 'assets', 'icons', 'clear-cache.svg'))
	
	// 托盘菜单也保留清除缓存选项
	const contextMenu = Menu.buildFromTemplate([
		{
			label: '显示/隐藏窗口 (快捷键注册中...)',
			click: function() {
				if (mainWindow) {
					if (mainWindow.isVisible()) {
						mainWindow.hide();
					} else {
						mainWindow.show();
						mainWindow.focus();
					}
				}
			}
		},
		{
			label: '清除缓存',
			icon: cacheIcon,
			click: function() {
				clearCache();
			}
		},
		{
			label: '退出',
			click: function() {
				app.quit();
				mainWindow.destroy();
			}
		}
	])

	// 添加清除缓存菜单到主窗口
	const mainMenu = Menu.buildFromTemplate([
		{
			label: '操作',
			submenu: [
				{
					label: '清除缓存',
					icon: cacheIcon,
					click: function() {
						clearCache();
					}
				},
				{ type: 'separator' },
				{ role: 'reload', label: '重新加载' },
				{ role: 'forceReload', label: '强制重新加载' },
				{ type: 'separator' },
				{ role: 'quit', label: '退出' }
			]
		}
	]);
	
	Menu.setApplicationMenu(mainMenu);

	tray.setToolTip('管理系统')
	// 任务栏图标双击托盘打开应用
	tray.on('double-click', function() {
		mainWindow.show();
	});
	// 单击托盘图标切换显示/隐藏
	tray.on('click', function() {
		if (mainWindow) {
			if (mainWindow.isVisible()) {
				mainWindow.hide();
			} else {
				mainWindow.show();
				mainWindow.focus();
			}
		}
	});
	tray.setContextMenu(contextMenu)

	mainWindow.on("close", (e) => {
		// 阻止窗口的关闭事件
		e.preventDefault();
		mainWindow.hide();
	});

	// 处理窗口控制按钮和清除缓存的IPC消息
	ipcMain.handle('clear-cache', async () => {
		console.log('收到clear-cache请求 - 开始处理');
		try {
			// 清除所有类型的缓存数据
			if (!mainWindow) {
				console.error('mainWindow不存在');
				return { success: false, message: '主窗口不存在' };
			}
			
			if (!mainWindow.webContents) {
				console.error('webContents不存在');
				return { success: false, message: 'Web内容不存在' };
			}
			
			const session = mainWindow.webContents.session;
			if (!session) {
				console.error('session不存在');
				return { success: false, message: '会话不存在' };
			}
			
			console.log('开始清除浏览器缓存...');
			await session.clearCache();
			console.log('缓存清除完成');
			
			console.log('开始清除存储数据...');
			await session.clearStorageData({
				storages: ['appcache', 'cookies', 'localstorage', 'caches', 'indexdb', 'websql', 'serviceworkers', 'shadercache']
			});
			console.log('存储数据清除完成');
			
			// 清除webview会话缓存
			console.log('开始清除webview缓存...');
			try {
				const webviewSession = session.fromPartition('persist:webcontent');
				await webviewSession.clearCache();
				await webviewSession.clearStorageData({
					storages: [
						'appcache',
						'filesystem',
						'caches',
						'shadercache',
						'websql',
						'serviceworkers',
						'cachestorage'
					]
				});
				console.log('webview缓存清除完成');
			} catch (error) {
				console.warn('清除webview缓存失败:', error);
			}
			
			// 向渲染进程发送重新加载远程内容的消息
			try {
				mainWindow.webContents.send('reload-webview');
				console.log('已发送reload-webview消息');
			} catch (error) {
				console.warn('发送reload-webview消息失败:', error);
			}
			
			console.log('缓存清除操作全部完成');
			return { success: true, message: '缓存清除成功' };
		} catch (error) {
			console.error('缓存清除失败:', error);
			return { success: false, message: '缓存清除失败: ' + error.message, error: error.toString() };
		}
	});
	
	// 添加新IPC处理程序，调用完整的clearCache函数
	ipcMain.handle('call-main-clear-cache', async () => {
		console.log('收到call-main-clear-cache请求 - 调用完整的clearCache函数');
		try {
			await clearCache();
			return { success: true, message: '缓存清除成功' };
		} catch (error) {
			console.error('主进程缓存清除失败:', error);
			return { success: false, message: '缓存清除失败: ' + error.message, error: error.toString() };
		}
	});
	
	// 菜单清除缓存处理程序 - 更直接的方式调用clearCache
	ipcMain.handle('menu-clear-cache', async () => {
		console.log('收到menu-clear-cache请求 - 直接调用clearCache函数');
		try {
			// 直接调用clearCache函数，它会处理通知、对话框等
			const result = await clearCache();
			return { success: true, message: '缓存清除成功', result };
		} catch (error) {
			console.error('通过菜单清除缓存失败:', error);
			return { success: false, message: '缓存清除失败: ' + error.message, error: error.toString() };
		}
	});
	
	// 处理新标签创建请求
	ipcMain.on('create-new-tab', (event, url) => {
		console.log('收到create-new-tab请求, URL:', url);
		// 将消息转发到渲染进程
		mainWindow.webContents.send('create-new-tab', url);
	});
	
	// 处理外部链接请求，使用系统默认浏览器打开
	ipcMain.on('open-external', (event, url) => {
		console.log('收到使用默认浏览器打开链接请求:', url);
		if (url && typeof url === 'string' && (url.startsWith('http://') || url.startsWith('https://'))) {
			console.log('尝试使用默认浏览器打开:', url);
			shell.openExternal(url).catch(err => {
				console.error('使用默认浏览器打开链接失败:', err);
			});
		} else {
			console.warn('无效的外部链接:', url);
		}
	});
	
	// 添加用于切换窗口显示/隐藏的IPC处理程序
	ipcMain.on('toggle-window-visibility', () => {
		console.log('收到从渲染进程切换窗口可见性的请求');
		if (mainWindow) {
			if (mainWindow.isVisible()) {
				console.log('通过IPC隐藏窗口');
				mainWindow.hide();
			} else {
				console.log('通过IPC显示窗口');
				mainWindow.show();
				mainWindow.focus();
				
				if (mainWindow.isMinimized()) {
					mainWindow.restore();
				}
			}
		}
	});
	
	ipcMain.on('minimize-window', () => {
		console.log('主进程收到最小化窗口请求');
		if (mainWindow) {
			try {
				mainWindow.minimize();
				console.log('窗口已最小化');
			} catch (err) {
				console.error('最小化窗口失败:', err);
			}
		} else {
			console.warn('无法最小化窗口: mainWindow不存在');
		}
	});
	
	ipcMain.on('maximize-window', () => {
		console.log('主进程收到最大化/还原窗口请求');
		if (mainWindow) {
			try {
				if (mainWindow.isMaximized()) {
					mainWindow.unmaximize();
					console.log('窗口已还原');
				} else {
					mainWindow.maximize();
					console.log('窗口已最大化');
				}
			} catch (err) {
				console.error('最大化/还原窗口失败:', err);
			}
		} else {
			console.warn('无法最大化/还原窗口: mainWindow不存在');
		}
	});
	
	ipcMain.on('close-window', () => {
		console.log('主进程收到关闭窗口请求');
		if (mainWindow) {
			try {
				mainWindow.hide();
				console.log('窗口已隐藏');
			} catch (err) {
				console.error('隐藏窗口失败:', err);
			}
		} else {
			console.warn('无法隐藏窗口: mainWindow不存在');
		}
	});

	// 获取当前注册的快捷键
	ipcMain.handle('get-registered-hotkey', () => {
		return registeredHotkey || '未注册';
	});

	// 启用开发者工具以方便调试（正式使用时可注释掉）
	// mainWindow.webContents.openDevTools();
}

// 清除浏览器缓存的函数
function clearCache() {
	console.log('执行clearCache函数');

	return new Promise((resolve, reject) => {
		if (mainWindow && mainWindow.webContents) {
			// 不发送开始清理的消息，直接清理

			// 排除cookies和localStorage，避免清除登录相关数据
			Promise.all([
				// 清除主会话缓存
				mainWindow.webContents.session.clearCache(),
				mainWindow.webContents.session.clearStorageData({ 
					storages: [
						'appcache',
						'filesystem',
						'indexdb',
						'shadercache',
						'websql',
						'serviceworkers',
						'cachestorage'
					]
				}),
				// 清除Webview会话缓存 (使用正确的方式处理)
				(() => {
					try {
						const webviewSession = session.fromPartition('persist:webcontent');
						return Promise.all([
							webviewSession.clearCache(),
							webviewSession.clearStorageData({ 
								storages: [
									'appcache',
									'filesystem',
									'caches',
									'shadercache',
									'websql',
									'serviceworkers',
									'cachestorage'
								]
							})
						]);
					} catch (err) {
						console.warn('清除webview会话失败:', err);
						return Promise.resolve(); // 即使失败也继续
					}
				})()
			])
			.then(async () => {
				console.log('所有缓存清除成功');
				// 不发送成功消息，直接显示对话框

				// 使用美化的对话框显示成功消息
				await showBeautifiedDialog({ 
					type: 'info',
					title: '缓存清除',
					message: '浏览器缓存已成功清除',
					buttons: ['确定'],
					defaultId: 0
				});

				// 向渲染进程发送重新加载远程内容的消息
				mainWindow.webContents.send('reload-webview');
				console.log('已发送 reload-webview 消息');

				resolve(true);
			}).catch(async (err) => {
				console.error('缓存清除失败:', err);
				// 不发送错误消息，直接显示对话框

				// 使用美化的对话框显示错误消息
				await showBeautifiedDialog({ 
					type: 'error',
					title: '错误',
					message: '清除缓存时发生错误: ' + err.message,
					buttons: ['确定'],
					defaultId: 0
				});
				reject(err);
			});
		} else {
			console.error('mainWindow或webContents不存在');
			reject(new Error('主窗口或网页内容不存在'));
		}
	});
}

// 显示错误消息的辅助函数
function showErrorMessage(err) {
	dialog.showMessageBox(mainWindow, {
		type: 'error',
		title: '错误',
		message: '清除缓存时发生错误: ' + err.message,
		buttons: ['确定']
	});
}

// 设置开机自启动
function setAutoStartup(enable) {
	console.log(`设置开机自启动: ${enable}`);
	try {
		app.setLoginItemSettings({
			openAtLogin: enable,
			// 在macOS上，可以设置以下选项
			openAsHidden: false, // 是否以隐藏状态启动
			path: process.execPath, // 应用程序路径
			args: [] // 启动参数
		});
		console.log('开机自启动设置成功');
	} catch (error) {
		console.error('设置开机自启动失败:', error);
	}
}

// This method will be called when Electron has finished
// initialization and is ready to create browser windows.
// Some APIs can only be used after this event occurs.
app.whenReady().then(() => {
	//  globalShortcut.register('Alt+B', function () {
	//       mainWindow.webContents.openDevTools();

	// })
	createWindow()
	
	// 设置开机自启动
	setAutoStartup(true);
	
	// 添加快捷键 Ctrl+Shift+R 来清除缓存
	globalShortcut.register('CommandOrControl+Shift+R', function() {
		clearCache();
	});

	// 尝试多种快捷键组合，防止系统冲突
	const hotkeyOptions = [
		'Alt+Q'  // 唯一快捷键
	];
	
	// 尝试注册多个快捷键
	let registeredHotkey = null;
	for (const hotkey of hotkeyOptions) {
		try {
			console.log(`尝试注册快捷键: ${hotkey}`);
			const success = globalShortcut.register(hotkey, function() {
				console.log(`触发快捷键: ${hotkey}`);
				if (!mainWindow) {
					console.log('mainWindow不存在，无法切换窗口状态');
					return;
				}
				
				if (mainWindow.isVisible()) {
					console.log('窗口当前可见，执行隐藏操作');
					mainWindow.hide();
				} else {
					console.log('窗口当前隐藏，执行显示操作');
					mainWindow.show();
					mainWindow.focus();
					
					// 如果窗口最小化，还原它
					if (mainWindow.isMinimized()) {
						console.log('窗口已最小化，还原窗口');
						mainWindow.restore();
					}
				}
			});
			
			if (success) {
				console.log(`成功注册快捷键: ${hotkey}`);
				registeredHotkey = hotkey;
				break;
			} else {
				console.warn(`快捷键注册失败: ${hotkey}`);
			}
		} catch (err) {
			console.error(`注册快捷键出错 ${hotkey}:`, err);
		}
	}
	
	if (registeredHotkey) {
		console.log(`最终使用的快捷键是: ${registeredHotkey}`);
		// 更新托盘菜单中的快捷键提示
		contextMenu.items[0].label = `显示/隐藏窗口 (${registeredHotkey})`;
		tray.setContextMenu(contextMenu);
	} else {
		console.error('所有快捷键注册都失败了！');
		dialog.showMessageBox(mainWindow, {
			type: 'warning',
			title: '快捷键注册失败',
			message: '无法注册快速显示/隐藏窗口的快捷键，可能与系统快捷键冲突。请使用托盘图标切换窗口。',
			buttons: ['确定']
		});
	}

	app.on('activate', function() {
		// On macOS it's common to re-create a window in the app when the
		// dock icon is clicked and there are no other windows open.
		if (BrowserWindow.getAllWindows().length === 0) createWindow()
	})
})

// Quit when all windows are closed, except on macOS. There, it's common
// for applications and their menu bar to stay active until the user quits
// explicitly with Cmd + Q.
app.on('window-all-closed', function() {
	// 注销所有全局快捷键
	globalShortcut.unregisterAll();
	app.quit();
})

// 应用退出前注销所有快捷键
app.on('will-quit', function() {
	// 注销所有快捷键
	globalShortcut.unregisterAll();
})

// In this file you can include the rest of your app's specific main process
// code. You can also put them in separate files and require them here.

// 从package.json读取应用版本
const packageJson = require('./package.json');
const APP_VERSION = packageJson.version; // 从package.json中获取版本号
const UPDATE_SERVER_URL = 'https://liwenyan.site/prod-api'; // 更新服务器地址

// 获取应用版本
ipcMain.handle('get-app-version', () => {
	return APP_VERSION;
});

/**
 * 显示美化版本的消息对话框
 * @param {Object} options 对话框选项
 * @returns {Promise<Object>} 用户响应
 */
async function showBeautifiedDialog(options) {
	// 如果主窗口不存在，使用原生对话框
	if (!mainWindow || mainWindow.isDestroyed()) {
		return dialog.showMessageBox(options);
	}

	return new Promise((resolve) => {
		// 生成唯一ID用于追踪此次对话框交互
		const dialogId = Date.now().toString();
		
		// 发送事件到渲染进程显示自定义对话框
		mainWindow.webContents.send('show-custom-dialog', {
			id: dialogId,
			...options
		});
		
		// 设置一次性监听器等待用户响应
		ipcMain.once(`dialog-response-${dialogId}`, (event, result) => {
			resolve(result);
		});
	});
}

/**
 * 检查更新函数
 * @param {boolean} silent 是否静默检查
 */
async function checkForUpdates(silent = false) {
	try {
		console.log('检查更新...');
		
		// 立即向主窗口发送正在检查更新的消息
		if (!silent && mainWindow && !mainWindow.isDestroyed()) {
			mainWindow.webContents.send('update-checking');
		}
		
		const response = await axios.get(`${UPDATE_SERVER_URL}/client/version/check`, {
			params: { currentVersion: APP_VERSION },
			timeout: 10000
		});
		
		console.log('检查更新响应:', response.data);
		
		// 如果有更新
		if (response.data.code === 200 && response.data.data) {
			const updateInfo = response.data.data;
			
			// 发送更新事件给渲染进程
			if (mainWindow) {
				mainWindow.webContents.send('update-available', updateInfo);
				
				// 如果是强制更新且是静默检查，也发送强制更新事件
				if (silent && updateInfo.forceUpdate === 'Y') {
					mainWindow.webContents.send('update-force-available', updateInfo);
				}
			}
			
			return { hasUpdate: true, updateInfo };
		} else {
			// 没有更新
			// 只有在非静默检查时才发送无更新事件
			if (!silent && mainWindow && !mainWindow.isDestroyed()) {
				mainWindow.webContents.send('update-not-available');
			}
			
			return { hasUpdate: false };
		}
	} catch (error) {
		console.error('检查更新失败:', error);
		
		// 只有在非静默检查时才发送错误事件
		if (!silent && mainWindow && !mainWindow.isDestroyed()) {
			mainWindow.webContents.send('update-error', { error: error.message });
		}
		
		if (!silent) {
			// 使用美化的对话框显示错误
			await showBeautifiedDialog({
				type: 'error',
				title: '检查更新失败',
				message: `检查更新时出错: ${error.message}`,
				buttons: ['确定'],
				defaultId: 0
			});
		}
		
		return { hasUpdate: false, error: error.message };
	}
}

// 检查更新
ipcMain.handle('check-for-updates', async (event, silent = false) => {
	return await checkForUpdates(silent);
});

// 下载更新
ipcMain.handle('download-update', async (event, url) => {
	try {
		const downloadPath = path.join(app.getPath('temp'), 'arvin-update.exe');
		await downloadFile(url, downloadPath);
		return { success: true, path: downloadPath };
	} catch (error) {
		console.error('下载更新失败:', error);
		return { success: false, error: error.message };
	}
});

// 安装更新
ipcMain.handle('install-update', async (event, filePath) => {
	try {
		console.log('开始安装更新:', filePath);
		shell.openPath(filePath);
		return { success: true };
	} catch (error) {
		console.error('安装更新失败:', error);
		return { success: false, error: error.message };
	}
});

// 重启应用
ipcMain.handle('restart-app', () => {
	app.relaunch();
	app.exit();
});

/**
 * 处理更新下载和安装
 * @param {Object} updateInfo 更新信息
 */
async function handleUpdateDownload(updateInfo) {
	try {
		// 向主窗口发送开始下载的消息
		if (mainWindow) {
			mainWindow.webContents.send('update-download-start', updateInfo);
		}
		
		// 下载路径
		const downloadPath = path.join(app.getPath('temp'), `arvin-update-${updateInfo.version}.exe`);
		console.log('下载路径:', downloadPath);
		
		// 开始下载
		try {
			// 移除可能存在的之前的下载文件
			if (fs.existsSync(downloadPath)) {
				fs.unlinkSync(downloadPath);
			}
			
			// 使用 HTTP/HTTPS 流式下载
			await downloadFileWithProgress(updateInfo.downloadUrl, downloadPath, (progress) => {
				// 向主窗口发送下载进度
				if (mainWindow && !mainWindow.isDestroyed()) {
					mainWindow.webContents.send('update-download-progress', progress);
				}
			});
			
			// 发送下载完成消息
			if (mainWindow && !mainWindow.isDestroyed()) {
				mainWindow.webContents.send('update-download-completed');
			}
			
			// 询问安装
			const result = await showBeautifiedDialog({
				type: 'info',
				title: '下载完成',
				message: '更新已下载完成，现在安装并重启应用?',
				buttons: ['立即安装', '稍后安装'],
				defaultId: 0,
				cancelId: 1
			});
			
			// 用户选择立即安装
			if (result.response === 0) {
				console.log('开始安装更新');
				await shell.openPath(downloadPath);
				app.exit(); // 退出应用以便安装
			}
			// 如果是强制更新
			else if (updateInfo.forceUpdate === 'Y') {
				await showBeautifiedDialog({
					type: 'warning',
					title: '强制更新',
					message: '当前版本需要强制更新，将继续安装。',
					buttons: ['确定'],
					defaultId: 0
				});
				
				await shell.openPath(downloadPath);
				app.exit(); // 退出应用以便安装
			}
		} catch (error) {
			console.error('下载或安装更新失败:', error);
			
			// 发送下载失败消息
			if (mainWindow && !mainWindow.isDestroyed()) {
				mainWindow.webContents.send('update-download-error', { error: error.message });
			}
			
			await showBeautifiedDialog({
				type: 'error',
				title: '更新失败',
				message: `下载或安装更新失败: ${error.message}`,
				buttons: ['确定'],
				defaultId: 0
			});
		}
	} catch (error) {
		console.error('处理更新过程失败:', error);
		
		// 发送下载失败消息
		if (mainWindow && !mainWindow.isDestroyed()) {
			mainWindow.webContents.send('update-download-error', { error: error.message });
		}
		
		await showBeautifiedDialog({
			type: 'error',
			title: '更新过程失败',
			message: `更新过程中发生错误: ${error.message}`,
			buttons: ['确定'],
			defaultId: 0
		});
	}
}

/**
 * 下载文件
 * @param {string} url 下载地址
 * @param {string} destination 保存路径
 */
function downloadFile(url, destination) {
	return new Promise((resolve, reject) => {
		try {
			const parsedUrl = new URL(url);
			const protocol = parsedUrl.protocol === 'https:' ? https : http;
			
			const request = protocol.get(url, (response) => {
				if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
					// 处理重定向
					return downloadFile(response.headers.location, destination)
						.then(resolve)
						.catch(reject);
				}
				
				if (response.statusCode !== 200) {
					return reject(new Error(`下载失败，HTTP状态码: ${response.statusCode}`));
				}
				
				const file = fs.createWriteStream(destination);
				
				file.on('finish', () => {
					file.close();
					resolve();
				});
				
				file.on('error', (err) => {
					fs.unlink(destination, () => {});
					reject(err);
				});
				
				response.pipe(file);
			});
			
			request.on('error', (err) => {
				fs.unlink(destination, () => {});
				reject(err);
			});
			
			request.end();
		} catch (error) {
			reject(error);
		}
	});
}

/**
 * 带进度的文件下载
 * @param {string} url 下载地址
 * @param {string} destination 保存路径
 * @param {Function} onProgress 进度回调
 */
function downloadFileWithProgress(url, destination, onProgress) {
	return new Promise((resolve, reject) => {
		try {
			const parsedUrl = new URL(url);
			const protocol = parsedUrl.protocol === 'https:' ? https : http;
			
			const request = protocol.get(url, (response) => {
				if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
					// 处理重定向
					return downloadFileWithProgress(response.headers.location, destination, onProgress)
						.then(resolve)
						.catch(reject);
				}
				
				if (response.statusCode !== 200) {
					return reject(new Error(`下载失败，HTTP状态码: ${response.statusCode}`));
				}
				
				const contentLength = parseInt(response.headers['content-length'] || '0', 10);
				let downloaded = 0;
				
				const file = fs.createWriteStream(destination);
				
				response.on('data', (chunk) => {
					downloaded += chunk.length;
					if (contentLength > 0 && typeof onProgress === 'function') {
						onProgress({
							percent: (downloaded / contentLength) * 100,
							transferred: downloaded,
							total: contentLength
						});
					}
				});
				
				file.on('finish', () => {
					file.close();
					resolve();
				});
				
				file.on('error', (err) => {
					fs.unlink(destination, () => {});
					reject(err);
				});
				
				response.pipe(file);
			});
			
			request.on('error', (err) => {
				fs.unlink(destination, () => {});
				reject(err);
			});
			
			request.end();
		} catch (error) {
			reject(error);
		}
	});
}

// 确认更新
ipcMain.handle('confirm-update', async () => {
	try {
		console.log('用户确认更新');
		
		// 获取最新的更新信息
		const response = await axios.get(`${UPDATE_SERVER_URL}/client/version/check`, {
			params: { currentVersion: APP_VERSION },
			timeout: 10000
		});
		
		if (response.data.code === 200 && response.data.data) {
			const updateInfo = response.data.data;
			// 处理更新下载
			await handleUpdateDownload(updateInfo);
			return { success: true };
		} else {
			console.error('确认更新时无法获取更新信息');
			return { success: false, error: '无法获取更新信息' };
		}
	} catch (error) {
		console.error('确认更新失败:', error);
		return { success: false, error: error.message };
	}
});

// 稍后更新
ipcMain.handle('postpone-update', () => {
	console.log('用户选择稍后更新');
	return { success: true };
});

// 处理自定义对话框响应
ipcMain.handle('dialog-response', (event, { id, response }) => {
	ipcMain.emit(`dialog-response-${id}`, event, { response });
	return { success: true };
});
